
#include <iostream>
#include <assert.h>
#include <stdlib.h>
#include <vector>

using namespace std;

// 类的大小，有关内存对齐
// this指针的问题
// vs下面对this指针进行优化，对象地址是放在ecx,ecx存储this指针的值
// 不能对this指针显示传递，但函数内部实现可以显示写，不过不建议
// 构造函数和析构函数 
// 构造函数可以重载
// 构造函数如果不写，编译器会自动生成，自动生成的对内置类型不做处理，对自定义类型调用它的默认构造
// 如果只有内置类型，析构函数可以不写，如果申请了资源就需要显示写析构函数

class A
{
public:
    A(int a = 1, int b = 1, char c = 'a')
    {
        _a = a;
        _b = b;
        _c = c;
    }

    void Print()
    {
        cout << _a << ' ' << _b << ' ' << _c << endl;
    }

private:
    int _a;
    int _b;
    char _c;
};

class Stack
{
public:
    Stack(int capacity = 4)
    {
        _a = (int*)malloc(sizeof(int) * capacity);
        assert(_a);

        _top = 0;
        _capacity = capacity;
    }

    ~Stack()
    {
        free(_a);
        _top = _capacity = 0;
    }

    void push(int x)
    {
        // 检查容量 。。。。。。扩容
        _a[_top ++ ] = x;
    }

    int top()
    {
        assert(!empty());
        return _a[_top - 1];
    }

    void pop()
    {
        _top -- ;
    }

    bool empty()
    {
        return _top == 0;
    }
    
private:
    int* _a;
    int _top;
    int _capacity;
};

int main()
{
    vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);

    for (auto e : v1)
    {
        cout << e << ' ';
    }
    cout << endl;
    
    cout << sizeof(A) << endl;
    cout << sizeof(Stack) << endl;

    A a;
    a.Print();

    Stack s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);

    while (!s.empty())
    {
        cout << s.top() << ' ';
        s.pop();
    }
    cout << endl;

    return 0;
}

